package com.dljd.javase.t15;

import com.dljd.javase.t15.Student;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ClassObject {


    public static void main(String[] args) {
        parseMethod();
//        parseConstructor();
//        parseField();

//        parseClass();
//        getClassObject();

    }

    /**
     * 获取字节码对象的方法
     */
    private static void getClassObject() {
        //如果要使用反射机制，先要获取类的字节码对象，字节码对象都是一种Class类型的对象

        //获取一个类的字节码对象方式有三种

        //1.通过Class.forName
        try {
           Class  c= Class.forName("com.dljd.javase.t5.Student");

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //2.通过类名.class

        Class c1= Student.class;

        //3.每个对象都有getClass方法，可以获取字节码对象
        Student  s=new Student();

        Class c2=s.getClass();
    }

    /**
     * 解析类中的方法的案例
     */
    public static void parseMethod(){

        Student sss=new Student();
        Class c=Student.class;

        try {
            Method m=c.getDeclaredMethod("eat",String.class);
            System.out.println(m.getName());
            System.out.println(m.getModifiers());
            System.out.println(m.getParameterCount());
            m.invoke(sss,"辣椒");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 解析类中构造方法的案例方法
     */
    public static void parseConstructor(){
        Class s=Student.class;

        try {
            Constructor cc=s.getDeclaredConstructor(String.class,int.class);
            Student stu=(Student) cc.newInstance("jack",123);

            System.out.println(stu);
            stu.jiguan="234";
        } catch (Exception e) {
            e.printStackTrace();
        }


//        Constructor[] cs=s.getDeclaredConstructors();
//        for(Constructor  c:cs){
//            System.out.println(c.getName()+"\t"+ c.getParameterCount());
//
//        }
    }


    /**
     * 反射解析出类中的属性（字段）（成员变量）之后可以对字段做更详细的解析和操作
     */
    public static  void parseField(){

        Student ss=new Student();
        ss.name="tens";
        Class s=Student.class;

        try {
            Field  f=s.getDeclaredField("jiazhang");


            f.setAccessible(true);
            System.out.println(f.get(ss));

            f.set(ss,"macheal");
            System.out.println(f.get(ss));
        } catch (Exception e) {
            e.printStackTrace();
        }

//        Field[]  fields=s.getDeclaredFields();

//        for(Field  f:fields){
//            try {
//                System.out.println(f.getName()+"="+f.get(ss));
//            } catch (IllegalAccessException e) {
//                e.printStackTrace();
//            }
////            System.out.println(f.getName()+"\t"+f.getType());
//        }
    }


    /**
     * 反射案例解析类的成员
     */
    public static void parseClass(){
        Class c1= Student.class;

        //解析类中的属性
        Field[] fields=c1.getDeclaredFields();

        //解析类中的方法
        Method[] methods=c1.getDeclaredMethods();

        //解析类中的构造方法
        Constructor[] constructors=c1.getConstructors();

        //解析类的本身信息
        System.out.println(c1.getSimpleName());

        //获取类的父类和上层接口信息
        Class  parents=c1.getSuperclass();
        System.out.println(parents.getName());

        Class[] parentIterface= c1.getInterfaces();

        for(Class c:parentIterface){
            System.out.println(c.getSimpleName());
        }
    }
}
